package com.xc.utils;


import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @author xingchen
 * @description 字符串工具类
 * @create 2021/11/19 9:27
 */
public class StringUtils extends org.apache.commons.lang3.StringUtils {

    public static final String TrueString = "True";

    public static final String FalseString = "False";

    private static final String[] DATE_FORMATS = {"yyyy-MM-dd", "yyyy/MM/dd", "yyyy.MM. dd", "yyyy年MM月dd日 "};

    private static final String[] TIME_FORMATS = {"HH时mm分ss秒", "HH :mm:ss", "HH时mm分", "HH:mm", "HH时", "HH", ""};

    /**
     * 将一个或者多个括号里的参数替换为指定的内容
     * Format("{0}_{1}","1","2") 如将括号里的0替换为1，将第二个括号里的1替换为2
     *
     * @param str
     * @param args
     * @return
     */
    public static String format(String str, Object... args) {

        if (isEmpty(str)) {
            return str;
        }

        if (args != null && args.length > 0) {
            for (int i = 0; i < args.length; i++) {
                String regex = "{" + i + "}";
                String replacement = args[i] == null ? null : args[i].toString();
                if (replacement != null) {
                    str = str.replace(regex, replacement);
                } else {
                    str = str.replace(regex, "");
                }
            }
        }

        return str;
    }

    /**
     * 将字符串转换为Int类型，若字符串为空或不能转换，将会用defaultValue 代替，defaultValue 值默认为Null
     *
     * @param str          要转换的字符串
     * @param defaultValue 出现异常时转换的默认值，默认为null
     * @return
     */
    public static Integer toInt(String str, Integer defaultValue) {
        if (str == null) {
            return defaultValue;
        }
        try {
            return Integer.parseInt(str);
        } catch (NumberFormatException ignored) {

        }
        return defaultValue;
    }

    /**
     * 将字符串转为Int类型，转换失败会抛出异常
     *
     * @param str 要转换的字符串
     * @return
     */
    public static Integer toInt(String str) {
        if (str == null) {
            return null;
        }
        return Integer.parseInt(str.trim());
    }

    /**
     * 将字符串转换为 Float 类型，若字符串为空或不能转换，将会用defaultValue 代替，defaultValue 值默认为Null
     *
     * @param str          要转换的字符串
     * @param defaultValue 出现异常时转换的默认值，默认为null
     * @return
     */
    public static Float toFloat(String str, Float defaultValue) {
        try {
            return Float.parseFloat(str);

        } catch (NumberFormatException ignored) {

        }
        return defaultValue;

    }

    /**
     * 将字符串转换为 Double 类型，若字符串为空或不能转换，将会用defaultValue 代替，defaultValue 值默认为Null
     *
     * @param str          要转换的字符串
     * @param defaultValue 出现异常时转换的默认值，默认为null
     * @return
     */
    public static Double toDouble(String str, Double defaultValue) {
        try {
            return Double.parseDouble(str);
        } catch (NumberFormatException ignored) {

        }
        return defaultValue;

    }

    /**
     * 将字符串转换为 Date 类型，若字符串为空或不能转换，将返回 Null
     *
     * @param str          要转换的字符串
     * @param defaultValue 出现异常时转换的默认值，默认为null
     * @return
     */
    public static Date toDateTime(String str, Date defaultValue) {
        try {
            if (StringUtils.isEmpty(str)) {
                return defaultValue;
            }
            String formatStr = "yyyy-MM-dd";
            if (str.contains("/")) {
                formatStr = "yyyy/MM/dd";
            }
            if (str.contains(":")) {
                String[] strary = str.split(":");
                if (strary.length == 2) {
                    formatStr = formatStr + "HH:mm";
                } else {
                    formatStr = formatStr + "HH:mm:ss";
                }
            }
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat(formatStr);
            return simpleDateFormat.parse(str);

        } catch (ParseException ignored) {

        }
        return defaultValue;
    }

    /**
     * 将字符串转换为 Boolean 类型，若字符串为空或不能转换，将返回null。支持0和1的转换
     *
     * @param str 要转换的字符串
     * @return
     */
    public static Boolean toBoolean(String str) {
        if (StringUtils.isEmpty(str)) {
            return null;
        }
        if ("0".equals(str)) {
            return false;
        }
        if ("1".equals(str)) {
            return true;
        }
        if (StringUtils.equalsAnyIgnoreCase("true", str)) {
            return true;
        }
        if (StringUtils.equalsAnyIgnoreCase("false", str)) {
            return false;
        }
        return null;
    }

    /**
     * 当传入的参数类型为String 和 Boolean 正常转换，若为其他类型的参数，默认返回值为null
     *
     * @param obj
     * @return
     */
    public static Boolean toBoolean(Object obj) {
        if (obj instanceof String) {
            return toBoolean((String) obj);
        }
        if (obj instanceof Boolean) {
            return (Boolean) obj;
        }
        return null;
    }

    public static Boolean toBoolean(String str, boolean defaultValue) {
        if (StringUtils.isEmpty(str)) {
            return defaultValue;
        }
        return toBoolean(str);
    }

    /**
     * 将字符串转换为 int 类型，但默认值不存在时，若字符串为空或不能转换，则返回该类型的默认值
     *
     * @param str
     * @param defaultValue 默认值，原为null
     * @return
     */
    public static int asInt(String str, Integer defaultValue) {
        Integer integer = toInt(str, null);
        if (integer == null) {
            return integer;
        }
        return defaultValue == null ? 0 : defaultValue;
    }

    /**
     * 将字符串转换为 bool 类型，当默认值不存在时，若字符串为空或不能转换，则返回该类型的默认值
     *
     * @param str
     * @param defaultValue 默认值，原默认值为null
     * @return
     */
    public static boolean asBoolean(String str, Boolean defaultValue) {
        //Out<Boolean> result = new Out<>();
        //TODO
        return true;
    }

    /**
     * 将字符串转换为 bool 类型，当默认值不存在时，若字符串为空或不能转换，则返回该类型的默认值.(特殊处理"0":false,"1":true)
     *
     * @param str
     * @param defaultValue
     * @return
     */
    public static boolean asBooleanSp(String str, Boolean defaultValue) {
        if ("0".equals(str)) {
            return false;
        } else if ("1".equals(str)) {
            return true;
        }
        return asBoolean(str, defaultValue);
    }

    /**
     * 将字符串转换为 DateTime 类型，当默认值不存在时，若字符串为空或不能转换，则返回该类型的默认值
     *
     * @param str
     * @param defaultValue
     * @return
     */
    public static Date asDateTime(String str, Date defaultValue) {
        Date date = toDateTime(str, defaultValue);
        if (date != null) {
            return date;
        }
        date = new Date(1, 1, 1, 0, 0, 1);
        return date;
    }

    /**
     * 裁掉字符串的字符
     *
     * @param str 需要被截取的字符串
     * @param var 截取的字符
     * @return
     */
    public static String trim(String str, String var) {
        str = trimStart(str, var);
        return trimEnd(str, var);
    }

    public static String trim(String str, String s, String e) {
        str = trimStart(str, s);
        return trimEnd(str, e);
    }

    /**
     * 截掉字符串最后的字符
     *
     * @param str 需要被截取的字符串
     * @param var 截取的字符
     * @return
     */
    public static String trimEnd(String str, String var) {
        while (isNotEmpty(str) && isNotEmpty(var) && str.endsWith(var)) {
            str = str.substring(0, str.length() - var.length());
        }
        return str;
    }

    /**
     * 对char类型的数据做处理
     *
     * @param str
     * @param var
     * @return
     */
    public static String trimEnd(String str, char var) {
        return trimEnd(str, String.valueOf(var));
    }

    /**
     * 截掉字符串开始的字符
     *
     * @param str 需要被截取的字符串
     * @param var 截取的字符
     * @return
     */
    public static String trimStart(String str, String var) {
        while (isNotEmpty(str) && isNotEmpty(var) && str.startsWith(var)) {
            str = str.substring(var.length());
        }
        return str;
    }

    /**
     * 截掉字符串之前的空格
     *
     * @param str 需要被截取的字符串
     * @return
     */
    public static String trimStart(String str) {
        while (isNotEmpty(str) && isEmpty(str.substring(0, 1).trim())) {
            str = str.substring(1);
        }
        return str;
    }

    /**
     * 字符串匹配，忽略大小写
     *
     * @param str
     * @param value
     * @return 返回0代表匹配，返回1代表不匹配
     */
    public static int indexOfIgnoreCase(String str, String value) {
        if (isEmpty(value)) {
            return 0;
        }
        return str.toUpperCase().indexOf(value.toUpperCase());
    }

    /**
     * 截取指定长度字符
     *
     * @param str
     * @param begin
     * @param length
     * @return
     */
    public static String substring(String str, int begin, int length) {
        return str.substring(begin, begin + length);
    }

    /**
     * 校验字符串是否为null，空白、空白字符串
     *
     * @param str
     * @return
     */
    public static boolean isNullOrWhiteSpace(String str) {
        return isEmpty(str) || isWhitespace(str);
    }

    /**
     * 校验字符串是否为null，空白、空白字符串，为空时，则返回默认字符串
     *
     * @param str
     * @param defaultValue
     * @return
     */
    public static String isNullOrWhiteSpace(String str, String defaultValue) {
        return isNullOrWhiteSpace(str) ? defaultValue : str;
    }

    /**
     * 将首字母转换为大写
     *
     * @param str
     * @return
     */
    public static String firstToUpper(String str) {
        char[] chars = str.toCharArray();
        if (chars[0] >= 'a' && chars[0] <= 'z') {
            chars[0] -= 32;
        }
        return String.valueOf(chars);
    }

    /**
     * 除了首字母，都转小写
     *
     * @param str
     * @return
     */
    public static String onlyFirstUpper(String str) {
        if (str == null) {
            return null;
        }
        char[] chars = str.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char c = chars[i];
            if (i == 0) {
                if (chars[i] >= 'a' && chars[i] <= 'z') {
                    chars[i] -= 32;
                }
            } else {
                if (chars[i] >= 'A' && chars[i] <= 'Z') {
                    chars[i] += 32;
                }
            }
        }
        return String.valueOf(chars);
    }



    public static void main(String[] args) {

        String ccc = onlyFirstUpper("accSAFASDDF");
        System.out.println(ccc);
    }
}